{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "164198ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import csv\n",
    "import matplotlib.pyplot as plt\n",
    "import osmnx as ox\n",
    "import transbigdata as tbd\n",
    "import pandas as pd\n",
    "from leuvenmapmatching.matcher.distance import DistanceMatcher\n",
    "from leuvenmapmatching.map.inmem import InMemMap\n",
    "from leuvenmapmatching import visualization as mmviz\n",
    "import geopandas as gpd\n",
    "from PIL import Image"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ec3d75a",
   "metadata": {},
   "source": [
    "## 获取osm路网"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "642c3fbf",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\38306\\AppData\\Local\\Temp\\ipykernel_1052\\1962375315.py:8: UserWarning: Geometry is in a geographic CRS. Results from 'centroid' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n",
      "\n",
      "  edges['lon'] = edges.centroid.x\n",
      "C:\\Users\\38306\\AppData\\Local\\Temp\\ipykernel_1052\\1962375315.py:9: UserWarning: Geometry is in a geographic CRS. Results from 'centroid' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n",
      "\n",
      "  edges['lat'] = edges.centroid.y\n"
     ]
    }
   ],
   "source": [
    "#根据一个点的坐标，获取半径为1500的OSM路网，半径随意选择\n",
    "center_point=(37.98009,23.735504)\n",
    "G=ox.graph.graph_from_point(center_point,dist=1500,simplify=True)\n",
    "\n",
    "\n",
    "#fig,ax = ox.plot_graph(G)\n",
    "nodes, edges = ox.graph_to_gdfs(G, nodes=True, edges=True)\n",
    "edges['lon'] = edges.centroid.x\n",
    "edges['lat'] = edges.centroid.y\n",
    "#转化投影坐标系\n",
    "G_p = ox.project_graph(G, to_crs=2416)\n",
    "nodes_p, edges_p = ox.graph_to_gdfs(G_p, nodes=True, edges=True)\n",
    "# 创建路网\n",
    "map_con = InMemMap(name='pNEUMA', use_latlon=False) # , use_rtree=True, index_edges=True)\n",
    "\n",
    "for node_id, row in nodes_p.iterrows():\n",
    "    map_con.add_node(node_id, (row['y'], row['x']))\n",
    "for node_id_1, node_id_2, _ in G_p.edges:\n",
    "    map_con.add_edge(node_id_1, node_id_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cdca9422",
   "metadata": {},
   "source": [
    "## 提取轨迹"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9175ff72",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 提取轨迹信息，轨迹文件为'trajectories.csv'\n",
    "data_raw = pd.read_csv('trajectories.csv')\n",
    "data = data_raw.to_numpy()\n",
    "\n",
    "result_list = []\n",
    "for row in data:\n",
    "    row_list = row[0].split(';')  # 用分号分割字符串\n",
    "    # 移除第三个和第四个元素\n",
    "    filtered_row = [row_list[i] for i in range(len(row_list)) if i not in []]\n",
    "    # 将每个元素转换为浮点数（如果可能的话）\n",
    "    float_row = []\n",
    "    for item in filtered_row:\n",
    "        try:\n",
    "            float_row.append(float(item))\n",
    "        except ValueError:\n",
    "            float_row.append(item)  # 如果无法转换为浮点数，则保持原样\n",
    "    result_list.append(float_row)\n",
    "    \n",
    "    \n",
    "# 去掉每个维度的最后一个元素\n",
    "#data = [sublist[:-1] for sublist in result_list]\n",
    "data = result_list\n",
    "data_four = [\n",
    "    [[data[i][0]]]+[[data[i][1]]] + [data[i][j:j+6] for j in range(2, len(data[i]), 6)]\n",
    "    for i in range(len(data))\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a51d2de",
   "metadata": {},
   "source": [
    "## 获取某条具体轨迹 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "50cf3a45",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\mini\\lib\\site-packages\\pyproj\\crs\\crs.py:141: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
      "  in_crs_string = _prepare_from_proj_string(in_crs_string)\n"
     ]
    }
   ],
   "source": [
    "# 要获取的轨迹索引\n",
    "i = 8900\n",
    "# 提取经纬度\n",
    "lat = [data_four[i][j][0] for j in range(2, len(data_four[i]))]\n",
    "lon = [data_four[i][j][1] for j in range(2, len(data_four[i]))]\n",
    "# 将经度和纬度值写入CSV文件\n",
    "with open('coordinates.csv', 'w', newline='') as csvfile:\n",
    "    fieldnames = ['lat', 'lon']\n",
    "    writer = csv.DictWriter(csvfile, fieldnames=fieldnames)\n",
    "\n",
    "    writer.writeheader()\n",
    "    for i in range(len(lat)):\n",
    "        writer.writerow({'lat': lat[i], 'lon': lon[i]})\n",
    "        \n",
    "data = pd.read_csv('coordinates.csv')\n",
    "data['geometry'] = gpd.points_from_xy(data['lon'], data['lat'])\n",
    "data= gpd.GeoDataFrame(data)\n",
    "data.crs = {'init': 'epsg:4326'}\n",
    "data = data.to_crs(2416)\n",
    "path = list(zip(data.geometry.y, data.geometry.x))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b75e756",
   "metadata": {},
   "source": [
    "## 绘图"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "98a6e002",
   "metadata": {},
   "outputs": [],
   "source": [
    "def picture(map_con,data,path,edges,i):\n",
    "    # create mapmatcher\n",
    "    matcher = DistanceMatcher(map_con,\n",
    "                              max_dist=500,\n",
    "                              max_dist_init=170,\n",
    "                              min_prob_norm=0.0001,\n",
    "                              non_emitting_length_factor=0.95,\n",
    "                              obs_noise=50,\n",
    "                              obs_noise_ne=50,\n",
    "                              dist_noise=50,\n",
    "                              max_lattice_width=20,\n",
    "                              non_emitting_states=True)\n",
    "    # mapmatching\n",
    "    states, _ = matcher.match(path, unique=False)\n",
    "    # plot the result\n",
    "    #mmviz.plot_map(map_con, matcher=matcher,show_labels=False, show_matching=True,show_graph=False,filename=None)\n",
    "\n",
    "    #Obtain the path GeoDataFrame\n",
    "    pathdf = pd.DataFrame(matcher.path_pred_onlynodes,columns = ['u'])\n",
    "    pathdf['v'] = pathdf['u'].shift(-1)\n",
    "    pathdf = pathdf[-pathdf['v'].isnull()]\n",
    "    pathgdf = pd.merge(pathdf,edges_p.reset_index())\n",
    "    pathgdf = gpd.GeoDataFrame(pathgdf)\n",
    "    #pathgdf.plot()\n",
    "    pathgdf.crs = {'init':'epsg:2416'}\n",
    "    pathgdf_4326 = pathgdf.to_crs(4326)\n",
    "\n",
    "    #Visualize with road network\n",
    "    fig     = plt.figure(1,(12,12),dpi = 100)\n",
    "    ax      = plt.subplot(111)\n",
    "    plt.sca(ax)\n",
    "    fig.tight_layout(rect = (0.05,0.1,1,0.9))\n",
    "    #visualization bounds\n",
    "    bounds = pathgdf_4326.unary_union.bounds\n",
    "    gap = 0.003\n",
    "    bounds = [bounds[0]-gap,bounds[1]-gap,bounds[2]+gap,bounds[3]+gap]\n",
    "    #plot the matched path\n",
    "    #pathgdf_4326.plot(ax = ax,zorder = 1)\n",
    "    #plot the road network geometry\n",
    "    tbd.clean_outofbounds(edges,bounds,col = ['lon','lat']).plot(ax = ax,color = '#333',lw = 0.1)\n",
    "    #plot the trajectory points\n",
    "    data.to_crs(4326).plot(ax = ax,color = 'b',markersize = 0.5,zorder = 2)\n",
    "\n",
    "    plt.axis('off')\n",
    "    plt.xlim(bounds[0],bounds[2])\n",
    "    plt.ylim(bounds[1],bounds[3])\n",
    "    file_name = f'picture/plot_{i}.png'\n",
    "    plt.savefig(file_name)\n",
    "    #plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3a6d31f",
   "metadata": {},
   "source": [
    "## 生成轨迹图片"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "a53c48d8",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Searching closeby nodes with linear search, use an index and set max_dist\n",
      "D:\\mini\\lib\\site-packages\\pyproj\\crs\\crs.py:141: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
      "  in_crs_string = _prepare_from_proj_string(in_crs_string)\n",
      "Searching closeby nodes with linear search, use an index and set max_dist\n",
      "D:\\mini\\lib\\site-packages\\pyproj\\crs\\crs.py:141: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
      "  in_crs_string = _prepare_from_proj_string(in_crs_string)\n",
      "Searching closeby nodes with linear search, use an index and set max_dist\n",
      "D:\\mini\\lib\\site-packages\\pyproj\\crs\\crs.py:141: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
      "  in_crs_string = _prepare_from_proj_string(in_crs_string)\n",
      "Searching closeby nodes with linear search, use an index and set max_dist\n",
      "D:\\mini\\lib\\site-packages\\pyproj\\crs\\crs.py:141: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
      "  in_crs_string = _prepare_from_proj_string(in_crs_string)\n",
      "Searching closeby nodes with linear search, use an index and set max_dist\n",
      "D:\\mini\\lib\\site-packages\\pyproj\\crs\\crs.py:141: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
      "  in_crs_string = _prepare_from_proj_string(in_crs_string)\n",
      "Searching closeby nodes with linear search, use an index and set max_dist\n",
      "D:\\mini\\lib\\site-packages\\pyproj\\crs\\crs.py:141: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
      "  in_crs_string = _prepare_from_proj_string(in_crs_string)\n",
      "Searching closeby nodes with linear search, use an index and set max_dist\n",
      "D:\\mini\\lib\\site-packages\\pyproj\\crs\\crs.py:141: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
      "  in_crs_string = _prepare_from_proj_string(in_crs_string)\n",
      "Searching closeby nodes with linear search, use an index and set max_dist\n",
      "D:\\mini\\lib\\site-packages\\pyproj\\crs\\crs.py:141: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
      "  in_crs_string = _prepare_from_proj_string(in_crs_string)\n",
      "Searching closeby nodes with linear search, use an index and set max_dist\n",
      "D:\\mini\\lib\\site-packages\\pyproj\\crs\\crs.py:141: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
      "  in_crs_string = _prepare_from_proj_string(in_crs_string)\n",
      "Searching closeby nodes with linear search, use an index and set max_dist\n",
      "D:\\mini\\lib\\site-packages\\pyproj\\crs\\crs.py:141: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
      "  in_crs_string = _prepare_from_proj_string(in_crs_string)\n",
      "Searching closeby nodes with linear search, use an index and set max_dist\n",
      "D:\\mini\\lib\\site-packages\\pyproj\\crs\\crs.py:141: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
      "  in_crs_string = _prepare_from_proj_string(in_crs_string)\n",
      "Searching closeby nodes with linear search, use an index and set max_dist\n",
      "D:\\mini\\lib\\site-packages\\pyproj\\crs\\crs.py:141: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
      "  in_crs_string = _prepare_from_proj_string(in_crs_string)\n",
      "Searching closeby nodes with linear search, use an index and set max_dist\n",
      "D:\\mini\\lib\\site-packages\\pyproj\\crs\\crs.py:141: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
      "  in_crs_string = _prepare_from_proj_string(in_crs_string)\n",
      "Searching closeby nodes with linear search, use an index and set max_dist\n",
      "D:\\mini\\lib\\site-packages\\pyproj\\crs\\crs.py:141: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
      "  in_crs_string = _prepare_from_proj_string(in_crs_string)\n",
      "Searching closeby nodes with linear search, use an index and set max_dist\n",
      "D:\\mini\\lib\\site-packages\\pyproj\\crs\\crs.py:141: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
      "  in_crs_string = _prepare_from_proj_string(in_crs_string)\n",
      "Searching closeby nodes with linear search, use an index and set max_dist\n",
      "D:\\mini\\lib\\site-packages\\pyproj\\crs\\crs.py:141: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
      "  in_crs_string = _prepare_from_proj_string(in_crs_string)\n",
      "Searching closeby nodes with linear search, use an index and set max_dist\n",
      "D:\\mini\\lib\\site-packages\\pyproj\\crs\\crs.py:141: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
      "  in_crs_string = _prepare_from_proj_string(in_crs_string)\n",
      "Searching closeby nodes with linear search, use an index and set max_dist\n",
      "D:\\mini\\lib\\site-packages\\pyproj\\crs\\crs.py:141: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
      "  in_crs_string = _prepare_from_proj_string(in_crs_string)\n",
      "Searching closeby nodes with linear search, use an index and set max_dist\n",
      "D:\\mini\\lib\\site-packages\\pyproj\\crs\\crs.py:141: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
      "  in_crs_string = _prepare_from_proj_string(in_crs_string)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Searching closeby nodes with linear search, use an index and set max_dist\n",
      "D:\\mini\\lib\\site-packages\\pyproj\\crs\\crs.py:141: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
      "  in_crs_string = _prepare_from_proj_string(in_crs_string)\n",
      "Searching closeby nodes with linear search, use an index and set max_dist\n",
      "D:\\mini\\lib\\site-packages\\pyproj\\crs\\crs.py:141: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
      "  in_crs_string = _prepare_from_proj_string(in_crs_string)\n",
      "Searching closeby nodes with linear search, use an index and set max_dist\n",
      "D:\\mini\\lib\\site-packages\\pyproj\\crs\\crs.py:141: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
      "  in_crs_string = _prepare_from_proj_string(in_crs_string)\n",
      "Searching closeby nodes with linear search, use an index and set max_dist\n",
      "D:\\mini\\lib\\site-packages\\pyproj\\crs\\crs.py:141: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
      "  in_crs_string = _prepare_from_proj_string(in_crs_string)\n",
      "Searching closeby nodes with linear search, use an index and set max_dist\n",
      "D:\\mini\\lib\\site-packages\\pyproj\\crs\\crs.py:141: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
      "  in_crs_string = _prepare_from_proj_string(in_crs_string)\n",
      "Searching closeby nodes with linear search, use an index and set max_dist\n",
      "D:\\mini\\lib\\site-packages\\pyproj\\crs\\crs.py:141: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
      "  in_crs_string = _prepare_from_proj_string(in_crs_string)\n",
      "Searching closeby nodes with linear search, use an index and set max_dist\n",
      "D:\\mini\\lib\\site-packages\\pyproj\\crs\\crs.py:141: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
      "  in_crs_string = _prepare_from_proj_string(in_crs_string)\n",
      "Searching closeby nodes with linear search, use an index and set max_dist\n",
      "D:\\mini\\lib\\site-packages\\pyproj\\crs\\crs.py:141: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
      "  in_crs_string = _prepare_from_proj_string(in_crs_string)\n",
      "Searching closeby nodes with linear search, use an index and set max_dist\n",
      "D:\\mini\\lib\\site-packages\\pyproj\\crs\\crs.py:141: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
      "  in_crs_string = _prepare_from_proj_string(in_crs_string)\n",
      "Searching closeby nodes with linear search, use an index and set max_dist\n",
      "D:\\mini\\lib\\site-packages\\pyproj\\crs\\crs.py:141: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
      "  in_crs_string = _prepare_from_proj_string(in_crs_string)\n",
      "Searching closeby nodes with linear search, use an index and set max_dist\n",
      "D:\\mini\\lib\\site-packages\\pyproj\\crs\\crs.py:141: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
      "  in_crs_string = _prepare_from_proj_string(in_crs_string)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x1200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 将 DataFrame 按行平均切割成三份\n",
    "split = list(range(25, len(data)+1, 25))\n",
    "# 初始化一个空列表来存储切割后的DataFrame\n",
    "split_data = []\n",
    "# 迭代切割点列表，逐步切割DataFrame\n",
    "for point in split:\n",
    "    split_data.append(data.iloc[:point])\n",
    "for i in range(30):\n",
    "    pathy = list(zip(split_data[i].geometry.y, split_data[i].geometry.x))    \n",
    "    picture(map_con,split_data[i],pathy,edges,i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1dc5d694",
   "metadata": {},
   "source": [
    "## 生成gif图像"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "9361d8ed",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 创建一个空的帧列表\n",
    "frames = []\n",
    "\n",
    "# 加载每个JPG图像并添加到帧列表中\n",
    "for i in range(30):\n",
    "    image_path = f\"picture/plot_{i}.png\"\n",
    "    frame = Image.open(image_path)\n",
    "    frames.append(frame)\n",
    "\n",
    "# 保存GIF图像\n",
    "output_path = \"out_1.gif\"\n",
    "frames[0].save(output_path, format=\"GIF\", append_images=frames[1:], save_all=True, duration=200, loop=0)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
